home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / c / amivogl-1.03.lzh / vogl / src / sunfort / fpoly.c.Z / fpoly.c
Encoding:
C/C++ Source or Header  |  1991-06-03  |  3.9 KB  |  443 lines
  1. #include "vogl.h"
  2.  
  3. /*
  4.  * polymode_
  5.  */
  6. void
  7. polymode_(onoff)
  8.     int    *onoff;
  9. {
  10.     polymode((long)*onoff);
  11. }
  12.  
  13. /*
  14.  * polymo_    (same as polymode_)
  15.  */
  16. void
  17. polymo_(onoff)
  18.     int    *onoff;
  19. {
  20.     polymode((long)*onoff);
  21. }
  22.  
  23. /*
  24.  * poly2_
  25.  */
  26. void
  27. poly2_(n, parray)
  28.     int    *n;
  29.     float    parray[][2];
  30. {
  31.     poly2((long)*n, parray);
  32. }
  33.  
  34. /*
  35.  * poly2s_
  36.  */
  37. void
  38. poly2s_(n, parray)
  39.     int    *n;
  40.     short    parray[][2];
  41. {
  42.     poly2s((long)*n, parray);
  43. }
  44.  
  45. /*
  46.  * poly2i_
  47.  */
  48. void
  49. poly2i_(n, parray)
  50.     int    *n;
  51.     Icoord    parray[][2];
  52. {
  53.     poly2i((long)*n, parray);
  54. }
  55.  
  56. /*
  57.  * poly_
  58.  */
  59. void
  60. poly_(n, parray)
  61.     int    *n;
  62.     float    parray[][3];
  63. {
  64.     poly((long)*n, parray);
  65. }
  66.  
  67. /*
  68.  * polys_
  69.  */
  70. void
  71. polys_(n, parray)
  72.     int    *n;
  73.     short    parray[][3];
  74. {
  75.     polys((long)*n, parray);
  76. }
  77.  
  78. /*
  79.  * polyi_
  80.  */
  81. void
  82. polyi_(n, parray)
  83.     int    *n;
  84.     Icoord    parray[][3];
  85. {
  86.     polyi((long)*n, parray);
  87. }
  88. /*
  89.  * polf_
  90.  */
  91. void
  92. polf_(n, parray)
  93.     int    *n;
  94.     float    parray[][3];
  95. {
  96.     polf((long)*n, parray);
  97. }
  98.  
  99. /*
  100.  * polfs_
  101.  */
  102. void
  103. polfs_(n, parray)
  104.     int    *n;
  105.     short    parray[][3];
  106. {
  107.     polfs((long)*n, parray);
  108. }
  109.  
  110. /*
  111.  * polfi_
  112.  */
  113. void
  114. polfi_(n, parray)
  115.     int    *n;
  116.     Icoord    parray[][3];
  117. {
  118.     polfi((long)*n, parray);
  119. }
  120.  
  121. /*
  122.  * polf2_
  123.  */
  124. void
  125. polf2_(n, parray)
  126.     int    *n;
  127.     float    parray[][2];
  128. {
  129.     polf2((long)*n, parray);
  130. }
  131.  
  132. /*
  133.  * polf2s_
  134.  */
  135. void
  136. polf2s_(n, parray)
  137.     int    *n;
  138.     short    parray[][2];
  139. {
  140.     polf2s((long)*n, parray);
  141. }
  142.  
  143. /*
  144.  * polf2i_
  145.  */
  146. void
  147. polf2i_(n, parray)
  148.     int    *n;
  149.     int    parray[][2];
  150. {
  151.     polf2i((long)*n, parray);
  152. }
  153.  
  154. /*
  155.  * pmv_
  156.  */
  157. void
  158. pmv_(x, y, z)
  159.     float     *x, *y, *z;
  160. {
  161.     pmv(*x, *y, *z);
  162. }
  163.  
  164. /*
  165.  * pmvs_
  166.  */
  167. void
  168. pmvs_(x, y, z)
  169.     short     *x, *y, *z;
  170. {
  171.     pmv((float)*x, (float)*y, (float)*z);
  172. }
  173.  
  174. /*
  175.  * pmvi_
  176.  */
  177. void
  178. pmvi_(x, y, z)
  179.     int     *x, *y, *z;
  180. {
  181.     pmv((float)*x, (float)*y, (float)*z);
  182. }
  183.  
  184. /*
  185.  * pmv2_
  186.  */
  187. void
  188. pmv2_(x, y)
  189.     float    *x, *y;
  190. {
  191.     pmv(*x, *y, 0.0);
  192. }
  193.  
  194. /*
  195.  * pmv2s_
  196.  */
  197. void
  198. pmv2s_(x, y)
  199.     short    *x, *y;
  200. {
  201.     pmv((float)*x, (float)*y, 0.0);
  202. }
  203.  
  204. /*
  205.  * pmv2i_
  206.  */
  207. void
  208. pmv2i_(x, y)
  209.     int    *x, *y;
  210. {
  211.     pmv((float)*x, (float)*y, 0.0);
  212. }
  213.  
  214. /*
  215.  * rpmv_
  216.  */
  217. void
  218. rpmv_(dx, dy, dz)
  219.     float    *dx, *dy, *dz;
  220. {
  221.     rpmv(*dx, *dy, *dz);
  222. }
  223.  
  224. /*
  225.  * rpmvs_
  226.  */
  227. void
  228. rpmvs_(dx, dy, dz)
  229.     short    *dx, *dy, *dz;
  230. {
  231.     rpmv((float)*dx, (float)*dy, (float)*dz);
  232. }
  233.  
  234. /*
  235.  * rpmvi_
  236.  */
  237. void
  238. rpmvi_(dx, dy, dz)
  239.     int    *dx, *dy, *dz;
  240. {
  241.     rpmv((float)*dx, (float)*dy, (float)*dz);
  242. }
  243.  
  244. /*
  245.  * rpmv2_
  246.  */
  247. void
  248. rpmv2_(dx, dy)
  249.     float    *dx, *dy;
  250. {
  251.     rpmv2(*dx, *dy);
  252. }
  253.  
  254. /*
  255.  * rpmv2s_
  256.  */
  257. void
  258. rpmv2s_(dx, dy)
  259.     short    *dx, *dy;
  260. {
  261.     rpmv2((float)*dx, (float)*dy);
  262. }
  263.  
  264. /*
  265.  * rpmv2i_
  266.  */
  267. void
  268. rpmv2i_(dx, dy)
  269.     int    *dx, *dy;
  270. {
  271.     rpmv2((float)*dx, (float)*dy);
  272. }
  273.  
  274.  
  275. /*
  276.  * pdr_
  277.  */
  278. void
  279. pdr_(x, y, z)
  280.     float     *x, *y, *z;
  281. {
  282.     pdr(*x, *y, *z);
  283. }
  284.  
  285. /*
  286.  * pdrs_
  287.  */
  288. void
  289. pdrs_(x, y, z)
  290.     short     *x, *y, *z;
  291. {
  292.     pdr((float)*x, (float)*y, (float)*z);
  293. }
  294.  
  295. /*
  296.  * pdri_
  297.  */
  298. void
  299. pdri_(x, y, z)
  300.     int     *x, *y, *z;
  301. {
  302.     pdr((float)*x, (float)*y, (float)*z);
  303. }
  304.  
  305. /*
  306.  * pdr2_
  307.  */
  308. void
  309. pdr2_(x, y)
  310.     float    *x, *y;
  311. {
  312.     pdr(*x, *y, 0.0);
  313. }
  314.  
  315. /*
  316.  * pdr2s_
  317.  */
  318. void
  319. pdr2s_(x, y)
  320.     short    *x, *y;
  321. {
  322.     pdr((float)*x, (float)*y, 0.0);
  323. }
  324.  
  325. /*
  326.  * pdr2i_
  327.  */
  328. void
  329. pdr2i_(x, y)
  330.     int    *x, *y;
  331. {
  332.     pdr((float)*x, (float)*y, 0.0);
  333. }
  334.  
  335. /*
  336.  * rpdr_
  337.  */
  338. void
  339. rpdr_(dx, dy, dz)
  340.     float    *dx, *dy, *dz;
  341. {
  342.     rpdr(*dx, *dy, *dz);
  343. }
  344.  
  345. /*
  346.  * rpdrs_
  347.  */
  348. void
  349. rpdrs_(dx, dy, dz)
  350.     short    *dx, *dy, *dz;
  351. {
  352.     rpdr((float)*dx, (float)*dy, (float)*dz);
  353. }
  354.  
  355. /*
  356.  * rpdri_
  357.  */
  358. void
  359. rpdri_(dx, dy, dz)
  360.     int    *dx, *dy, *dz;
  361. {
  362.     rpdr((float)*dx, (float)*dy, (float)*dz);
  363. }
  364.  
  365. /*
  366.  * rpdr2_
  367.  */
  368. void
  369. rpdr2_(dx, dy)
  370.     float    *dx, *dy;
  371. {
  372.     rpdr2(*dx, *dy);
  373. }
  374.  
  375. /*
  376.  * rpdr2s_
  377.  */
  378. void
  379. rpdr2s_(dx, dy)
  380.     short    *dx, *dy;
  381. {
  382.     rpdr2((float)*dx, (float)*dy);
  383. }
  384.  
  385. /*
  386.  * rpdr2i_
  387.  */
  388. void
  389. rpdr2i_(dx, dy)
  390.     int    *dx, *dy;
  391. {
  392.     rpdr2((float)*dx, (float)*dy);
  393. }
  394.  
  395. /*
  396.  * pclos_
  397.  */
  398. void
  399. pclos_()
  400. {
  401.     pclos();
  402. }
  403.  
  404. /*
  405.  * backface_
  406.  */
  407. void
  408. backface_(onoff)
  409.     int    *onoff;
  410. {
  411.     backface(*onoff);
  412. }
  413.  
  414. /*
  415.  * backfa_
  416.  */
  417. void
  418. backfa_(onoff)
  419.     int    *onoff;
  420. {
  421.     backface(*onoff);
  422. }
  423.  
  424. /*
  425.  * frontface_
  426.  */
  427. void
  428. frontface_(onoff)
  429.     int    *onoff;
  430. {
  431.     frontface(*onoff);
  432. }
  433.  
  434. /*
  435.  * frontf_
  436.  */
  437. void
  438. frontf_(onoff)
  439.     int    *onoff;
  440. {
  441.     frontface(*onoff);
  442. }
  443.